// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.warehouse;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.Warehouse;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(Warehouse.class)
@Setter
@Getter
public class WarehouseSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "Warehouse".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("supplierId", "s");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：Warehouse/LocalAndOverseas, Warehouse/FBABin, Warehouse/SelectHide
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 仓库名称(模糊搜索)
   */
  private String name;

  /**
   * 仓库名称 比较(eq)
   */
  private String nameEq;
  /**
   * 仓库名称 比较(neq)
   */
  private String nameNeq;
  /**
   * 仓库名称 比较(gt)
   */
  private String nameGt;
  /**
   * 仓库名称 比较(gte)
   */
  private String nameGte;
  /**
   * 仓库名称 比较(lt)
   */
  private String nameLt;
  /**
   * 仓库名称 比较(lte)
   */
  private String nameLte;
  /**
   * 仓库名称 比较(contains)
   */
  private String nameContains;
  /**
   * 仓库名称 比较(notcontains)
   */
  private String nameNotcontains;
  /**
   * 仓库名称 比较(startswith)
   */
  private String nameStartswith;
  /**
   * 仓库名称 比较(endswith)
   */
  private String nameEndswith;
  /**
   * 仓库名称 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 仓库名称 比较(isnotnull)
   */
  private Boolean nameIsnotnull;

  /**
   * 仓库名称(精确搜索)
   */
  private List<String> nameInList;

  /**
   * 属性
   */
  private String widType;

  /**
   * 属性 比较(eq)
   */
  private String widTypeEq;
  /**
   * 属性 比较(neq)
   */
  private String widTypeNeq;
  /**
   * 属性 比较(gt)
   */
  private String widTypeGt;
  /**
   * 属性 比较(gte)
   */
  private String widTypeGte;
  /**
   * 属性 比较(lt)
   */
  private String widTypeLt;
  /**
   * 属性 比较(lte)
   */
  private String widTypeLte;
  /**
   * 属性 比较(contains)
   */
  private String widTypeContains;
  /**
   * 属性 比较(notcontains)
   */
  private String widTypeNotcontains;
  /**
   * 属性 比较(startswith)
   */
  private String widTypeStartswith;
  /**
   * 属性 比较(endswith)
   */
  private String widTypeEndswith;
  /**
   * 属性 比较(isnull)
   */
  private Boolean widTypeIsnull;
  /**
   * 属性 比较(isnotnull)
   */
  private Boolean widTypeIsnotnull;

  /**
   * 属性(精确搜索)
   */
  private List<String> widTypeInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 负责人(模糊搜索)
   */
  private String contact;

  /**
   * 负责人 比较(eq)
   */
  private String contactEq;
  /**
   * 负责人 比较(neq)
   */
  private String contactNeq;
  /**
   * 负责人 比较(gt)
   */
  private String contactGt;
  /**
   * 负责人 比较(gte)
   */
  private String contactGte;
  /**
   * 负责人 比较(lt)
   */
  private String contactLt;
  /**
   * 负责人 比较(lte)
   */
  private String contactLte;
  /**
   * 负责人 比较(contains)
   */
  private String contactContains;
  /**
   * 负责人 比较(notcontains)
   */
  private String contactNotcontains;
  /**
   * 负责人 比较(startswith)
   */
  private String contactStartswith;
  /**
   * 负责人 比较(endswith)
   */
  private String contactEndswith;
  /**
   * 负责人 比较(isnull)
   */
  private Boolean contactIsnull;
  /**
   * 负责人 比较(isnotnull)
   */
  private Boolean contactIsnotnull;

  /**
   * 负责人(精确搜索)
   */
  private List<String> contactInList;

  /**
   * 联系电话(模糊搜索)
   */
  private String telephone;

  /**
   * 联系电话 比较(eq)
   */
  private String telephoneEq;
  /**
   * 联系电话 比较(neq)
   */
  private String telephoneNeq;
  /**
   * 联系电话 比较(gt)
   */
  private String telephoneGt;
  /**
   * 联系电话 比较(gte)
   */
  private String telephoneGte;
  /**
   * 联系电话 比较(lt)
   */
  private String telephoneLt;
  /**
   * 联系电话 比较(lte)
   */
  private String telephoneLte;
  /**
   * 联系电话 比较(contains)
   */
  private String telephoneContains;
  /**
   * 联系电话 比较(notcontains)
   */
  private String telephoneNotcontains;
  /**
   * 联系电话 比较(startswith)
   */
  private String telephoneStartswith;
  /**
   * 联系电话 比较(endswith)
   */
  private String telephoneEndswith;
  /**
   * 联系电话 比较(isnull)
   */
  private Boolean telephoneIsnull;
  /**
   * 联系电话 比较(isnotnull)
   */
  private Boolean telephoneIsnotnull;

  /**
   * 联系电话(精确搜索)
   */
  private List<String> telephoneInList;

  /**
   * 仓库地址(模糊搜索)
   */
  private String address;

  /**
   * 仓库地址 比较(eq)
   */
  private String addressEq;
  /**
   * 仓库地址 比较(neq)
   */
  private String addressNeq;
  /**
   * 仓库地址 比较(gt)
   */
  private String addressGt;
  /**
   * 仓库地址 比较(gte)
   */
  private String addressGte;
  /**
   * 仓库地址 比较(lt)
   */
  private String addressLt;
  /**
   * 仓库地址 比较(lte)
   */
  private String addressLte;
  /**
   * 仓库地址 比较(contains)
   */
  private String addressContains;
  /**
   * 仓库地址 比较(notcontains)
   */
  private String addressNotcontains;
  /**
   * 仓库地址 比较(startswith)
   */
  private String addressStartswith;
  /**
   * 仓库地址 比较(endswith)
   */
  private String addressEndswith;
  /**
   * 仓库地址 比较(isnull)
   */
  private Boolean addressIsnull;
  /**
   * 仓库地址 比较(isnotnull)
   */
  private Boolean addressIsnotnull;

  /**
   * 仓库地址(精确搜索)
   */
  private List<String> addressInList;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 待检待上架量
   */
  private Integer quantityTest;

  /**
   * 最小待检待上架量
   */
  private Integer quantityTestMin;

  /**
   * 最大待检待上架量
   */
  private Integer quantityTestMax;

  /**
   * 待检待上架量 比较(eq)
   */
  private Integer quantityTestEq;
  /**
   * 待检待上架量 比较(neq)
   */
  private Integer quantityTestNeq;
  /**
   * 待检待上架量 比较(gt)
   */
  private Integer quantityTestGt;
  /**
   * 待检待上架量 比较(gte)
   */
  private Integer quantityTestGte;
  /**
   * 待检待上架量 比较(lt)
   */
  private Integer quantityTestLt;
  /**
   * 待检待上架量 比较(lte)
   */
  private Integer quantityTestLte;
  /**
   * 待检待上架量 比较(contains)
   */
  private Integer quantityTestContains;
  /**
   * 待检待上架量 比较(notcontains)
   */
  private Integer quantityTestNotcontains;
  /**
   * 待检待上架量 比较(startswith)
   */
  private Integer quantityTestStartswith;
  /**
   * 待检待上架量 比较(endswith)
   */
  private Integer quantityTestEndswith;
  /**
   * 待检待上架量 比较(isnull)
   */
  private Boolean quantityTestIsnull;
  /**
   * 待检待上架量 比较(isnotnull)
   */
  private Boolean quantityTestIsnotnull;

  /**
   * 待到货量
   */
  private Integer quantityAog;

  /**
   * 最小待到货量
   */
  private Integer quantityAogMin;

  /**
   * 最大待到货量
   */
  private Integer quantityAogMax;

  /**
   * 待到货量 比较(eq)
   */
  private Integer quantityAogEq;
  /**
   * 待到货量 比较(neq)
   */
  private Integer quantityAogNeq;
  /**
   * 待到货量 比较(gt)
   */
  private Integer quantityAogGt;
  /**
   * 待到货量 比较(gte)
   */
  private Integer quantityAogGte;
  /**
   * 待到货量 比较(lt)
   */
  private Integer quantityAogLt;
  /**
   * 待到货量 比较(lte)
   */
  private Integer quantityAogLte;
  /**
   * 待到货量 比较(contains)
   */
  private Integer quantityAogContains;
  /**
   * 待到货量 比较(notcontains)
   */
  private Integer quantityAogNotcontains;
  /**
   * 待到货量 比较(startswith)
   */
  private Integer quantityAogStartswith;
  /**
   * 待到货量 比较(endswith)
   */
  private Integer quantityAogEndswith;
  /**
   * 待到货量 比较(isnull)
   */
  private Boolean quantityAogIsnull;
  /**
   * 待到货量 比较(isnotnull)
   */
  private Boolean quantityAogIsnotnull;

  /**
   * 预计总量
   */
  private Integer estimatedTotal;

  /**
   * 最小预计总量
   */
  private Integer estimatedTotalMin;

  /**
   * 最大预计总量
   */
  private Integer estimatedTotalMax;

  /**
   * 预计总量 比较(eq)
   */
  private Integer estimatedTotalEq;
  /**
   * 预计总量 比较(neq)
   */
  private Integer estimatedTotalNeq;
  /**
   * 预计总量 比较(gt)
   */
  private Integer estimatedTotalGt;
  /**
   * 预计总量 比较(gte)
   */
  private Integer estimatedTotalGte;
  /**
   * 预计总量 比较(lt)
   */
  private Integer estimatedTotalLt;
  /**
   * 预计总量 比较(lte)
   */
  private Integer estimatedTotalLte;
  /**
   * 预计总量 比较(contains)
   */
  private Integer estimatedTotalContains;
  /**
   * 预计总量 比较(notcontains)
   */
  private Integer estimatedTotalNotcontains;
  /**
   * 预计总量 比较(startswith)
   */
  private Integer estimatedTotalStartswith;
  /**
   * 预计总量 比较(endswith)
   */
  private Integer estimatedTotalEndswith;
  /**
   * 预计总量 比较(isnull)
   */
  private Boolean estimatedTotalIsnull;
  /**
   * 预计总量 比较(isnotnull)
   */
  private Boolean estimatedTotalIsnotnull;

  /**
   * 总量
   */
  private Integer gross;

  /**
   * 最小总量
   */
  private Integer grossMin;

  /**
   * 最大总量
   */
  private Integer grossMax;

  /**
   * 总量 比较(eq)
   */
  private Integer grossEq;
  /**
   * 总量 比较(neq)
   */
  private Integer grossNeq;
  /**
   * 总量 比较(gt)
   */
  private Integer grossGt;
  /**
   * 总量 比较(gte)
   */
  private Integer grossGte;
  /**
   * 总量 比较(lt)
   */
  private Integer grossLt;
  /**
   * 总量 比较(lte)
   */
  private Integer grossLte;
  /**
   * 总量 比较(contains)
   */
  private Integer grossContains;
  /**
   * 总量 比较(notcontains)
   */
  private Integer grossNotcontains;
  /**
   * 总量 比较(startswith)
   */
  private Integer grossStartswith;
  /**
   * 总量 比较(endswith)
   */
  private Integer grossEndswith;
  /**
   * 总量 比较(isnull)
   */
  private Boolean grossIsnull;
  /**
   * 总量 比较(isnotnull)
   */
  private Boolean grossIsnotnull;

  /**
   * 费用
   */
  private Integer cost;

  /**
   * 最小费用
   */
  private Integer costMin;

  /**
   * 最大费用
   */
  private Integer costMax;

  /**
   * 费用 比较(eq)
   */
  private Integer costEq;
  /**
   * 费用 比较(neq)
   */
  private Integer costNeq;
  /**
   * 费用 比较(gt)
   */
  private Integer costGt;
  /**
   * 费用 比较(gte)
   */
  private Integer costGte;
  /**
   * 费用 比较(lt)
   */
  private Integer costLt;
  /**
   * 费用 比较(lte)
   */
  private Integer costLte;
  /**
   * 费用 比较(contains)
   */
  private Integer costContains;
  /**
   * 费用 比较(notcontains)
   */
  private Integer costNotcontains;
  /**
   * 费用 比较(startswith)
   */
  private Integer costStartswith;
  /**
   * 费用 比较(endswith)
   */
  private Integer costEndswith;
  /**
   * 费用 比较(isnull)
   */
  private Boolean costIsnull;
  /**
   * 费用 比较(isnotnull)
   */
  private Boolean costIsnotnull;

  /**
   * 头程
   */
  private Integer theFirstVessel;

  /**
   * 最小头程
   */
  private Integer theFirstVesselMin;

  /**
   * 最大头程
   */
  private Integer theFirstVesselMax;

  /**
   * 头程 比较(eq)
   */
  private Integer theFirstVesselEq;
  /**
   * 头程 比较(neq)
   */
  private Integer theFirstVesselNeq;
  /**
   * 头程 比较(gt)
   */
  private Integer theFirstVesselGt;
  /**
   * 头程 比较(gte)
   */
  private Integer theFirstVesselGte;
  /**
   * 头程 比较(lt)
   */
  private Integer theFirstVesselLt;
  /**
   * 头程 比较(lte)
   */
  private Integer theFirstVesselLte;
  /**
   * 头程 比较(contains)
   */
  private Integer theFirstVesselContains;
  /**
   * 头程 比较(notcontains)
   */
  private Integer theFirstVesselNotcontains;
  /**
   * 头程 比较(startswith)
   */
  private Integer theFirstVesselStartswith;
  /**
   * 头程 比较(endswith)
   */
  private Integer theFirstVesselEndswith;
  /**
   * 头程 比较(isnull)
   */
  private Boolean theFirstVesselIsnull;
  /**
   * 头程 比较(isnotnull)
   */
  private Boolean theFirstVesselIsnotnull;

  /**
   * 库存成本
   */
  private Integer stockHoldingCost;

  /**
   * 最小库存成本
   */
  private Integer stockHoldingCostMin;

  /**
   * 最大库存成本
   */
  private Integer stockHoldingCostMax;

  /**
   * 库存成本 比较(eq)
   */
  private Integer stockHoldingCostEq;
  /**
   * 库存成本 比较(neq)
   */
  private Integer stockHoldingCostNeq;
  /**
   * 库存成本 比较(gt)
   */
  private Integer stockHoldingCostGt;
  /**
   * 库存成本 比较(gte)
   */
  private Integer stockHoldingCostGte;
  /**
   * 库存成本 比较(lt)
   */
  private Integer stockHoldingCostLt;
  /**
   * 库存成本 比较(lte)
   */
  private Integer stockHoldingCostLte;
  /**
   * 库存成本 比较(contains)
   */
  private Integer stockHoldingCostContains;
  /**
   * 库存成本 比较(notcontains)
   */
  private Integer stockHoldingCostNotcontains;
  /**
   * 库存成本 比较(startswith)
   */
  private Integer stockHoldingCostStartswith;
  /**
   * 库存成本 比较(endswith)
   */
  private Integer stockHoldingCostEndswith;
  /**
   * 库存成本 比较(isnull)
   */
  private Boolean stockHoldingCostIsnull;
  /**
   * 库存成本 比较(isnotnull)
   */
  private Boolean stockHoldingCostIsnotnull;

  /**
   * 总计
   */
  private Integer total;

  /**
   * 最小总计
   */
  private Integer totalMin;

  /**
   * 最大总计
   */
  private Integer totalMax;

  /**
   * 总计 比较(eq)
   */
  private Integer totalEq;
  /**
   * 总计 比较(neq)
   */
  private Integer totalNeq;
  /**
   * 总计 比较(gt)
   */
  private Integer totalGt;
  /**
   * 总计 比较(gte)
   */
  private Integer totalGte;
  /**
   * 总计 比较(lt)
   */
  private Integer totalLt;
  /**
   * 总计 比较(lte)
   */
  private Integer totalLte;
  /**
   * 总计 比较(contains)
   */
  private Integer totalContains;
  /**
   * 总计 比较(notcontains)
   */
  private Integer totalNotcontains;
  /**
   * 总计 比较(startswith)
   */
  private Integer totalStartswith;
  /**
   * 总计 比较(endswith)
   */
  private Integer totalEndswith;
  /**
   * 总计 比较(isnull)
   */
  private Boolean totalIsnull;
  /**
   * 总计 比较(isnotnull)
   */
  private Boolean totalIsnotnull;

  /**
   * 仓位
   */
  private Long posId;

  /**
   * 最小仓位
   */
  private Long posIdMin;

  /**
   * 最大仓位
   */
  private Long posIdMax;

  /**
   * 仓位 比较(eq)
   */
  private Long posIdEq;
  /**
   * 仓位 比较(neq)
   */
  private Long posIdNeq;
  /**
   * 仓位 比较(gt)
   */
  private Long posIdGt;
  /**
   * 仓位 比较(gte)
   */
  private Long posIdGte;
  /**
   * 仓位 比较(lt)
   */
  private Long posIdLt;
  /**
   * 仓位 比较(lte)
   */
  private Long posIdLte;
  /**
   * 仓位 比较(contains)
   */
  private Long posIdContains;
  /**
   * 仓位 比较(notcontains)
   */
  private Long posIdNotcontains;
  /**
   * 仓位 比较(startswith)
   */
  private Long posIdStartswith;
  /**
   * 仓位 比较(endswith)
   */
  private Long posIdEndswith;
  /**
   * 仓位 比较(isnull)
   */
  private Boolean posIdIsnull;
  /**
   * 仓位 比较(isnotnull)
   */
  private Boolean posIdIsnotnull;

  /**
   * 仓库属性(删除字段)
   */
  private String type;

  /**
   * 仓库属性(删除字段) 比较(eq)
   */
  private String typeEq;
  /**
   * 仓库属性(删除字段) 比较(neq)
   */
  private String typeNeq;
  /**
   * 仓库属性(删除字段) 比较(gt)
   */
  private String typeGt;
  /**
   * 仓库属性(删除字段) 比较(gte)
   */
  private String typeGte;
  /**
   * 仓库属性(删除字段) 比较(lt)
   */
  private String typeLt;
  /**
   * 仓库属性(删除字段) 比较(lte)
   */
  private String typeLte;
  /**
   * 仓库属性(删除字段) 比较(contains)
   */
  private String typeContains;
  /**
   * 仓库属性(删除字段) 比较(notcontains)
   */
  private String typeNotcontains;
  /**
   * 仓库属性(删除字段) 比较(startswith)
   */
  private String typeStartswith;
  /**
   * 仓库属性(删除字段) 比较(endswith)
   */
  private String typeEndswith;
  /**
   * 仓库属性(删除字段) 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 仓库属性(删除字段) 比较(isnotnull)
   */
  private Boolean typeIsnotnull;

  /**
   * 仓库属性(删除字段)(精确搜索)
   */
  private List<String> typeInList;

  /**
   * 仓库类型(删除字段)
   */
  private String isOwn;

  /**
   * 仓库类型(删除字段) 比较(eq)
   */
  private String isOwnEq;
  /**
   * 仓库类型(删除字段) 比较(neq)
   */
  private String isOwnNeq;
  /**
   * 仓库类型(删除字段) 比较(gt)
   */
  private String isOwnGt;
  /**
   * 仓库类型(删除字段) 比较(gte)
   */
  private String isOwnGte;
  /**
   * 仓库类型(删除字段) 比较(lt)
   */
  private String isOwnLt;
  /**
   * 仓库类型(删除字段) 比较(lte)
   */
  private String isOwnLte;
  /**
   * 仓库类型(删除字段) 比较(contains)
   */
  private String isOwnContains;
  /**
   * 仓库类型(删除字段) 比较(notcontains)
   */
  private String isOwnNotcontains;
  /**
   * 仓库类型(删除字段) 比较(startswith)
   */
  private String isOwnStartswith;
  /**
   * 仓库类型(删除字段) 比较(endswith)
   */
  private String isOwnEndswith;
  /**
   * 仓库类型(删除字段) 比较(isnull)
   */
  private Boolean isOwnIsnull;
  /**
   * 仓库类型(删除字段) 比较(isnotnull)
   */
  private Boolean isOwnIsnotnull;

  /**
   * 仓库类型(删除字段)(精确搜索)
   */
  private List<String> isOwnInList;

  /**
   * 仓库类型名称(模糊搜索)
   */
  private String isOwnName;

  /**
   * 仓库类型名称 比较(eq)
   */
  private String isOwnNameEq;
  /**
   * 仓库类型名称 比较(neq)
   */
  private String isOwnNameNeq;
  /**
   * 仓库类型名称 比较(gt)
   */
  private String isOwnNameGt;
  /**
   * 仓库类型名称 比较(gte)
   */
  private String isOwnNameGte;
  /**
   * 仓库类型名称 比较(lt)
   */
  private String isOwnNameLt;
  /**
   * 仓库类型名称 比较(lte)
   */
  private String isOwnNameLte;
  /**
   * 仓库类型名称 比较(contains)
   */
  private String isOwnNameContains;
  /**
   * 仓库类型名称 比较(notcontains)
   */
  private String isOwnNameNotcontains;
  /**
   * 仓库类型名称 比较(startswith)
   */
  private String isOwnNameStartswith;
  /**
   * 仓库类型名称 比较(endswith)
   */
  private String isOwnNameEndswith;
  /**
   * 仓库类型名称 比较(isnull)
   */
  private Boolean isOwnNameIsnull;
  /**
   * 仓库类型名称 比较(isnotnull)
   */
  private Boolean isOwnNameIsnotnull;

  /**
   * 仓库类型名称(精确搜索)
   */
  private List<String> isOwnNameInList;

  /**
   * 供应商
   */
  private Long supplierId;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierIdEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierIdNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierIdGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierIdGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierIdLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierIdLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierIdContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierIdNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierIdStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierIdEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierIdIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierIdIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierIdSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierIdSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierIdSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierIdSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierIdSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierIdSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierIdSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierIdSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierIdSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierIdSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierIdSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierIdSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierIdInList;

  /**
   * 仓库编码(模糊搜索)
   */
  private String wid;

  /**
   * 仓库编码 比较(eq)
   */
  private String widEq;
  /**
   * 仓库编码 比较(neq)
   */
  private String widNeq;
  /**
   * 仓库编码 比较(gt)
   */
  private String widGt;
  /**
   * 仓库编码 比较(gte)
   */
  private String widGte;
  /**
   * 仓库编码 比较(lt)
   */
  private String widLt;
  /**
   * 仓库编码 比较(lte)
   */
  private String widLte;
  /**
   * 仓库编码 比较(contains)
   */
  private String widContains;
  /**
   * 仓库编码 比较(notcontains)
   */
  private String widNotcontains;
  /**
   * 仓库编码 比较(startswith)
   */
  private String widStartswith;
  /**
   * 仓库编码 比较(endswith)
   */
  private String widEndswith;
  /**
   * 仓库编码 比较(isnull)
   */
  private Boolean widIsnull;
  /**
   * 仓库编码 比较(isnotnull)
   */
  private Boolean widIsnotnull;

  /**
   * 仓库编码(精确搜索)
   */
  private List<String> widInList;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 最小店铺
   */
  private Long sidMin;

  /**
   * 最大店铺
   */
  private Long sidMax;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
